#ifndef UNIFIEDTHREADMANAGER_H
#define UNIFIEDTHREADMANAGER_H

#include "itask.h"
#include "systemresourcemonitor.h"
#include <QObject>
#include <QThreadPool>
#include <QTimer>
#include <QMutex>
#include <QQueue>
#include <QMap>
#include <QRunnable>
#include <QDateTime>
#include <memory>

/**
 * @brief 任务包装器，用于在线程池中执行ITask
 */
class TaskWrapper : public QRunnable {
public:
    explicit TaskWrapper(std::shared_ptr<ITask> task, class UnifiedThreadManager* manager);
    void run() override;

private:
    std::shared_ptr<ITask> m_task;
    UnifiedThreadManager* m_manager;
};

/**
 * @brief 统一线程管理器
 * 
 * 核心控制器，负责：
 * - 智能任务调度
 * - 线程池管理
 * - 资源监控和自适应调整
 * - 进度通知
 * 
 * 使用Singleton模式，确保全局唯一性
 */
class UnifiedThreadManager : public QObject {
    Q_OBJECT
    
public:
    /**
     * @brief 调度策略枚举
     */
    enum class SchedulingStrategy {
        FIFO,           // 先进先出
        Priority,       // 优先级调度
        LoadBalanced,   // 负载均衡
        Adaptive        // 自适应调度
    };
    
    /**
     * @brief 任务状态枚举
     */
    enum class TaskStatus {
        Queued,         // 排队中
        Running,        // 运行中
        Completed,      // 已完成
        Failed,         // 失败
        Cancelled       // 已取消
    };
    
    /**
     * @brief 任务信息结构体
     */
    struct TaskInfo {
        std::shared_ptr<ITask> task;
        TaskStatus status;
        QDateTime queueTime;
        QDateTime startTime;
        QDateTime endTime;
        QString errorMessage;
        
        TaskInfo() : status(TaskStatus::Queued) {}
        TaskInfo(std::shared_ptr<ITask> t) : task(t), status(TaskStatus::Queued) {
            queueTime = QDateTime::currentDateTime();
        }
    };
    
    /**
     * @brief 获取单例实例
     */
    static UnifiedThreadManager* instance();
    
    /**
     * @brief 提交任务
     * @param task 要执行的任务
     * @return 任务是否成功提交
     */
    bool submitTask(std::shared_ptr<ITask> task);
    
    /**
     * @brief 取消任务
     * @param taskId 任务ID
     * @return 是否成功取消
     */
    bool cancelTask(const QString& taskId);
    
    /**
     * @brief 暂停任务调度
     */
    void pauseScheduling();
    
    /**
     * @brief 恢复任务调度
     */
    void resumeScheduling();
    
    /**
     * @brief 添加进度观察者
     * @param observer 观察者指针
     */
    void addProgressObserver(IProgressObserver* observer);
    
    /**
     * @brief 移除进度观察者
     * @param observer 观察者指针
     */
    void removeProgressObserver(IProgressObserver* observer);
    
    /**
     * @brief 设置调度策略
     * @param strategy 调度策略
     */
    void setSchedulingStrategy(SchedulingStrategy strategy);
    
    /**
     * @brief 设置最大并发任务数
     * @param maxTasks 最大任务数
     */
    void setMaxConcurrentTasks(int maxTasks);
    
    /**
     * @brief 设置内存限制
     * @param memoryLimit 内存限制（字节）
     */
    void setMemoryLimit(qint64 memoryLimit);
    
    /**
     * @brief 启用自适应调度
     * @param enabled 是否启用
     */
    void enableAdaptiveScheduling(bool enabled);
    
    /**
     * @brief 获取任务信息
     * @param taskId 任务ID
     * @return 任务信息
     */
    TaskInfo getTaskInfo(const QString& taskId) const;
    
    /**
     * @brief 获取所有任务信息
     * @return 任务信息列表
     */
    QList<TaskInfo> getAllTasks() const;
    
    /**
     * @brief 获取队列中的任务数量
     * @return 任务数量
     */
    int getQueuedTaskCount() const;
    
    /**
     * @brief 获取运行中的任务数量
     * @return 任务数量
     */
    int getRunningTaskCount() const;
    
    /**
     * @brief 获取已完成的任务数量
     * @return 任务数量
     */
    int getCompletedTaskCount() const;
    
    /**
     * @brief 清除已完成的任务记录
     */
    void clearCompletedTasks();

signals:
    /**
     * @brief 任务状态变化信号
     * @param taskId 任务ID
     * @param status 新状态
     */
    void taskStatusChanged(const QString& taskId, TaskStatus status);
    
    /**
     * @brief 线程池状态变化信号
     * @param activeThreads 活跃线程数
     * @param maxThreads 最大线程数
     */
    void threadPoolStatusChanged(int activeThreads, int maxThreads);

public slots:
    /**
     * @brief 任务完成回调
     * @param taskId 任务ID
     * @param successful 是否成功
     * @param errorMessage 错误信息（如果失败）
     */
    void onTaskCompleted(const QString& taskId, bool successful, const QString& errorMessage = QString());
    
    /**
     * @brief 任务进度更新回调
     * @param taskId 任务ID
     * @param progress 进度百分比
     * @param status 状态描述
     */
    void onTaskProgress(const QString& taskId, int progress, const QString& status);

private slots:
    void processQueue();
    void adjustResourceAllocation();
    void onResourceUpdated(const SystemResourceMonitor::ResourceInfo& info);

private:
    explicit UnifiedThreadManager(QObject* parent = nullptr);
    ~UnifiedThreadManager();
    
    // 禁用拷贝构造和赋值
    UnifiedThreadManager(const UnifiedThreadManager&) = delete;
    UnifiedThreadManager& operator=(const UnifiedThreadManager&) = delete;
    
    // 单例实例
    static UnifiedThreadManager* s_instance;
    static QMutex s_instanceMutex;
    
    // 核心组件
    std::unique_ptr<QThreadPool> m_threadPool;
    SystemResourceMonitor* m_resourceMonitor;
    
    // 任务管理
    QQueue<std::shared_ptr<ITask>> m_taskQueue;
    QMap<QString, TaskInfo> m_allTasks;
    QMap<QString, std::shared_ptr<ITask>> m_runningTasks;
    mutable QMutex m_tasksMutex;
    
    // 观察者列表
    QList<IProgressObserver*> m_observers;
    mutable QMutex m_observersMutex;
    
    // 调度配置
    SchedulingStrategy m_strategy;
    int m_maxConcurrentTasks;
    qint64 m_memoryLimit;
    bool m_adaptiveSchedulingEnabled;
    bool m_schedulingPaused;
    
    // 定时器
    QTimer* m_queueProcessTimer;
    QTimer* m_resourceAdjustTimer;
    
    // 内部方法
    void initializeThreadPool();
    void startTimers();
    void stopTimers();
    
    std::shared_ptr<ITask> selectNextTask();
    std::shared_ptr<ITask> selectTaskFIFO();
    std::shared_ptr<ITask> selectTaskByPriority();
    std::shared_ptr<ITask> selectTaskLoadBalanced();
    std::shared_ptr<ITask> selectTaskAdaptive();
    
    bool canExecuteTask(std::shared_ptr<ITask> task);
    void executeTask(std::shared_ptr<ITask> task);
    void notifyObservers(const QString& taskId, int progress, const QString& status);
    void notifyTaskCompleted(const QString& taskId);
    void notifyTaskFailed(const QString& taskId, const QString& error);
    void notifyTaskStarted(const QString& taskId);
    void notifyTaskCancelled(const QString& taskId);
    
    void updateTaskStatus(const QString& taskId, TaskStatus status, const QString& errorMessage = QString());
    
    // 友元类
    friend class TaskWrapper;
};

#endif // UNIFIEDTHREADMANAGER_H
